package cn.yangsen.simplebeanmanager.engine;

import java.lang.reflect.Field;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import javax.persistence.Entity;

import org.apache.commons.lang3.StringUtils;

import cn.yangsen.simplebeanmanager.annotation.作为一个超链接;
import cn.yangsen.simplebeanmanager.annotation.级联;
import cn.yangsen.simplebeanmanager.annotation.限定范围;
import cn.yangsen.simplebeanmanager.bean.html.A;
import cn.yangsen.simplebeanmanager.bean.html.Element;
import cn.yangsen.simplebeanmanager.bean.html.Label;
import cn.yangsen.simplebeanmanager.tool.ReflectTool;

public class 展示用表格生成器 extends 表格生成器
{
	SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	@Override
	protected Element[] 处理Boolean属性值(Field 属性, Boolean 值)
	{
		Element[] 结果 = new Element[1];
		if (值 != null)
		{
			Label 文本 = new Label();
			结果[0] = 文本;
			if (值)
			{
				文本.setContent("是");
			}
			else
			{
				文本.setContent("否");
			}
		}
		return 结果;
	}

	@Override
	protected Element[] 处理Int属性值(Field 属性, Integer 值)
	{
		Element[] 结果 = new Element[1];
		if (值 != null)
		{
			Label 文本 = new Label();
			结果[0] = 文本;
			文本.setContent(Integer.toString(值));
		}
		return 结果;
	}

	@Override
	protected Element[] 处理Long属性值(Field 属性, Long 值)
	{
		Element[] 结果 = new Element[1];
		if (值 != null)
		{
			Label 文本 = new Label();
			结果[0] = 文本;
			文本.setContent(Long.toString(值));
		}
		return 结果;
	}

	@Override
	protected Element[] 处理Float属性值(Field 属性, Float 值)
	{
		Element[] 结果 = new Element[1];
		if (值 != null)
		{
			Label 文本 = new Label();
			结果[0] = 文本;
			文本.setContent(Float.toString(值));
		}
		return 结果;
	}

	@Override
	protected Element[] 处理String属性值(Field 属性, Object 值)
	{
		Element[] 结果 = new Element[1];
		if (值 != null)
		{
			Label 文本 = new Label();
			结果[0] = 文本;
			文本.setContent((String) 值);
		}
		return 结果;
	}

	@Override
	protected Element[] 处理日期属性值(Field 属性, Date 值)
	{
		Element[] 结果 = new Element[1];
		if (值 != null)
		{
			Label 文本 = new Label();
			结果[0] = 文本;

			Calendar c = Calendar.getInstance();
			c.setTime(值);
			文本.setContent(df.format(值));
		}
		return 结果;
	}

	@Override
	protected Element[] 处理Enum属性值(Field 属性, Object 值)
	{
		Element[] 结果 = new Element[1];
		if (值 != null)
		{
			Label 文本 = new Label();
			结果[0] = 文本;
			文本.setContent(获取枚举的描述((Enum<?>) 值));
		}
		return 结果;
	}

	@Override
	protected <T> Element[] 处理Iterable属性值(Field 属性, Iterable<? extends T> 值, Class<? extends T> 实际类型)
	{
		Element[] 结果 = new Element[1];

		if (值 != null)
		{
			if (实际类型 == Float.class)
			{
				结果 = new Element[1];
				结果[0] = 生成标题栏在上方的简单对象表格(实际类型, 值);
			}
			else
			{
				结果[0] = 生成标题栏在上方的表格(实际类型, 值);
			}
		}
		return 结果;
	}

	@Override
	protected Element[] 处理Abstract属性值(Field 属性, Object 值)
	{
		Element[] 结果 = new Element[1];
		if (值 != null)
		{
			Entity e = 值.getClass().getAnnotation(Entity.class);
			if (e != null)
			{
				Label 文本 = new Label();
				if (StringUtils.isEmpty(e.name()))
				{
					文本.setContent(值.getClass().getSimpleName());
				}
				else
				{
					文本.setContent(e.name());
				}
				结果[0] = 文本;
			}
		}
		return 结果;
	}

	@Override
	protected Element[] 处理Id注解的属性值(Object 对象, Field 属性)
	{
		Element[] 结果 = new Element[1];
		Object 值 = ReflectTool.获取对象的属性值(对象, 属性);
		if (值 != null)
		{
			Label 文本 = new Label();
			结果[0] = 文本;
			文本.setContent(值.toString());
		}
		return 结果;
	}

	@Override
	protected Element[] 处理Entity注解的属性值(Field 属性, Object 值)
	{
		Element[] 结果 = new Element[1];
		if (值 != null)
		{
			ArrayList<Object> list = new ArrayList<>(1);
			list.add(值);
			结果[0] = 生成标题栏在左侧的表格(属性.getType(), list);
		}
		return 结果;
	}

	@Override
	protected Element[] 处理AsA注解的属性值(Object 对象, Field 属性)
	{
		Element[] 结果 = new Element[1];
		Object 值 = ReflectTool.获取对象的属性值(对象, 属性);
		if (值 != null)
		{
			作为一个超链接 超链接 = 属性.getAnnotation(作为一个超链接.class);
			if (超链接 != null)
			{
				A a = 根据注解组装超链接(超链接, 值);
				结果[0] = a;
			}
		}
		return 结果;
	}

	@Override
	protected Element[] 处理Rely注解的属性值(Object 对象, Field 属性)
	{
		Element[] 结果 = new Element[1];
		Object 值 = ReflectTool.获取对象的属性值(对象, 属性);
		if (值 != null)
		{
			Label 文本 = new Label();
			结果[0] = 文本;
			文本.setContent(String.valueOf(值));
		}
		return 结果;
	}

	@Override
	protected Element[] 处理限定范围的简单属性值(Object 对象, Field 属性)
	{
		限定范围 范围 = 属性.getAnnotation(限定范围.class);
		if (范围 == null)
		{
			return null;
		}
		Object 值 = ReflectTool.获取对象的属性值(对象, 属性);
		Element[] 结果 = new Element[1];
		if (值 != null)
		{
			Label 文本 = new Label();
			结果[0] = 文本;
			文本.setContent(获取限定范围时显示内容(范围, 值));
		}

		return 结果;
	}

	@Override
	protected Element[] 处理限定范围的Iterable属性值(Object 对象, Field 属性)
	{
		限定范围 范围 = 属性.getAnnotation(限定范围.class);
		if (范围 == null)
		{
			return null;
		}
		Object 值 = ReflectTool.获取对象的属性值(对象, 属性);
		Element[] 结果 = new Element[1];
		if (值 != null)
		{
			if (值 instanceof Iterable)
			{
				Label 文本 = new Label();
				结果[0] = 文本;
				StringBuilder sb = new StringBuilder();
				boolean isFirst = true;
				for (Object 单个 : (Iterable<?>) 值)
				{
					String 显示值 = 获取限定范围时显示内容(范围, 单个);
					if (显示值 != null)
					{
						if (!isFirst)
						{
							sb.append("\n");
						}
						isFirst = false;
						sb.append(显示值);
					}
				}
				文本.setContent(sb.toString());
			}
		}

		return 结果;
	}

	@Override
	protected Element[][] 处理级联属性(Field 属性, Object 对象, Set<Field> 已被级联处理的属性)
	{
		List<Element[]> 结果 = new LinkedList<>();
		结果.add(处理单个属性(属性, 对象));
		级联 级联 = 属性.getAnnotation(级联.class);
		if (级联 != null)
		{
			String 被控制的属性名 = 级联.control();
			Field 被控制属性 = ReflectTool.获取对象的属性(对象, 被控制的属性名);
			if (被控制属性 != null)
			{
				已被级联处理的属性.add(被控制属性);
				Object 控制方的值 = ReflectTool.获取对象的属性值(对象, 属性);
				if (控制方的值 != null)
				{
					Object 被控制方的值 = ReflectTool.获取对象的属性值(对象, 被控制属性);
					if (被控制方的值 != null)
					{
						Object 被控制方的值的可能范围 = null;
						String 方法名 = 级联.metion();
						if (级联.isLocalMetion())
						{
							被控制方的值的可能范围 = ReflectTool.执行方法(对象, 方法名, 控制方的值);
						}
						else
						{
							被控制方的值的可能范围 = ReflectTool.执行方法(控制方的值, 方法名);
						}
						if (被控制方的值的可能范围 != null)
						{
							String 作为参数传递的关键字方法名 = 级联.key();
							Object 被控制方的值所在的对象 = null;
							if (被控制方的值的可能范围 instanceof Iterable)
							{
								for (Object obj : (Iterable<?>) 被控制方的值的可能范围)
								{
									Object 当前值对应的关键参数 = ReflectTool.执行方法(obj, 作为参数传递的关键字方法名);
									if (被控制方的值.equals(当前值对应的关键参数))
									{
										被控制方的值所在的对象 = obj;
										break;
									}
								}
							}
							Label 文本 = new Label();
							结果.add(new Element[]
								{ 文本 });
							if (被控制方的值所在的对象 != null)
							{
								String 显示方法名 = 级联.show();
								Object 显示内容 = ReflectTool.执行方法(被控制方的值所在的对象, 显示方法名);
								if (显示内容 != null)
								{
									文本.setContent((String) 显示内容);
								}
							}
						}
					}
				}
			}
		}
		return 结果.toArray(new Element[2][]);
	}

	@Override
	protected Element[][] 处理简单对象集合(Iterable<?> 对象集合)
	{
		if (对象集合 == null)
		{
			return null;
		}
		ArrayList<Element[]> list = new ArrayList<>();
		for (Object object : 对象集合)
		{
			list.add(new Element[]
				{ new Label(object.toString()) });
		}
		return list.toArray(new Element[list.size()][]);
	}
}
